'use strict';

const pAny = require('p-any');
const unless = require('koa-unless');
const verify = require('./verify');
const getSecret = require('./get-secret');
const resolveAuthHeader = require('./resolvers/auth-header');
const resolveCookies = require('./resolvers/cookie');

module.exports = (opts = {}) => {
    // opts配置参数对象
    const { debug, getToken, isRevoked, key = 'user', passthrough, tokenKey } = opts;

    // resolveCookies 处理存储在cookie中的token，要在opts中传入cookie字段
    // resolveAuthHeader 处理存储在请求头部中authorization字段的token
    const tokenResolvers = [resolveCookies, resolveAuthHeader];

    // getToken自定义获取token的函数，返回值为boolean。优先使用getToken
    if (getToken && typeof getToken === 'function') {
        tokenResolvers.unshift(getToken);
    }

    const middleware = async function jwt(ctx, next) {
        let token;
        tokenResolvers.find(resolver => token = resolver(ctx, opts));

        if (!token && !passthrough) {
            ctx.throw(401, debug ? 'Token not found' : 'Authentication Error');
        }

        let { state: { secret = opts.secret } } = ctx;

        try {
            // 获取secret
            if (typeof secret === 'function') {
                secret = await getSecret(secret, token);
            }
            
            if (!secret) {
                throw new Error('Secret not provided');
            }
            // 解密token，得到的decodedTokens是一个包含用户信息对象的数组
            let secrets = Array.isArray(secret) ? secret : [secret];
            const decodedTokens = secrets.map(async s => await verify(token, s, opts));
            
            // pAny 处理decodeTokens数组
            // pAny 输入参数An `Iterable` collection of promises/values to wait for.
            // pAny返回一个Promise p1，首先decodeTokens数组经过封装后变成一个Promise数组，若其中任一个Promsie成功则返回成功状态p1，若全部Promise失败则返回以AggregateError为reason的失败状态p1，有点类似some
            const decodedToken = await pAny(decodedTokens)
                .catch(function (err) {
                    if (err instanceof pAny.AggregateError) {
                        for (const e of err) {
                            throw e;
                        }
                    } else {
                        throw err;
                    }
                });
            // isResolved函数根据提供的解析的用户信息和token进行操作处理，决定是否撤销权限
            if (isRevoked) {
                const tokenRevoked = await isRevoked(ctx, decodedToken, token);
                if (tokenRevoked) {
                    throw new Error('Token revoked');
                }
            }
        // 存储用户信息的JSON对象，默认存储在ctx.state.user上
            ctx.state[key] = decodedToken;
            // 若传入tokenKey则将token存储在ctx.state.tokenKey上
            if (tokenKey) {
                ctx.state[tokenKey] = token;
            }

        } catch (e) {
            // 传入passthrough，决定先不抛出错误，由服务端先进行处理
            // 将错误信息先存储在ctx.state.jwtOriginalError上
            if (!passthrough) {
                const msg = debug ? e.message : 'Authentication Error';
                ctx.throw(401, msg, { originalError: e });
            }else{ 
                //lets downstream middlewares handle JWT exceptions
                ctx.state.jwtOriginalError = e;
            }
        }
        // 内部自动next了，不要再重复next，会报错
        return next();
    };
    // 可以使用unless函数，进行控制哪些路由需要jwt验证，哪些接口不需要验证
    middleware.unless = unless;
    return middleware;
};
